package com.augurit.gis.flex;

import java.util.ArrayList;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.List;
import java.sql.Timestamp;
import java.util.*;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;

import java.io.*;
import java.text.*;
import java.sql.*;
import javax.servlet.http.*;
import java.lang.reflect.Field;

/**
 * <p>题目: 公有方法类</p>
 * <p>描述: 提供一系列常用的公有方法</p>
 * <p>版权所有: Copyright (c) 2007</p>
 * <p>公司: 广州奥格智能科技有限公司</p>
 * @author 韩启明
 * @version 1.0
 */


public class Utils {

  /**
   *日期格式包含年月日，如：2003-10-01
   */
  public final static String YEAR_MOUTH_DAY = "yyyy-MM-dd";
  /**
   *紧凑型日期格式包含年月日，如：20031001
   */
  public final static String YEAR_MOUTH_DAY_C = "yyyyMMdd";
  /**
   *日期格式包含年、月、日、小时、分钟、秒、毫秒，如：2003-10-01 10:20:15:200
   */
  public final static String YEAR_TO_MSECOND = "yyyy-MM-dd HH:mm:ss:SSS";
  /**
   *紧凑型日期格式包含年、月、日、小时、分钟、秒、毫秒，如：20031001102015200
   */
  public final static String YEAR_TO_MSECOND_C = "yyyyMMddHHmmssSSS";
  /**
   *紧凑型日期格式包含年、月、日、小时、分钟、秒,如：20031001102015
   */
  public final static String YEAR_TO_SECOND_C = "yyyyMMddHHmmss";
  /**
   *日期格式包含年月，如：2003-10
   */
  public final static String YEAR_MOUTH = "yyyy-MM";
  /**
   *紧凑型日期格式包含年月，如：200310
   */
  public final static String YEAR_MOUTH_C = "yyyyMM";

  /**
   *日期格式包含年、月、日，如：2003-10-01
   */
  public final static String SIMPLE_DATE = "yyyy-MM-dd";
  /**
   *日期格式包含年、月、日，如：2003-10-01 12:02:02
   */
  public final static String SIMPLE_DATE_TIME = "yyyy-MM-dd HH:mm:ss";

  public final static String SIMPLE_DATE_MINTUE="yyyy-MM-dd HH:mm";

  public final static String SIMPLE_DATE_MONTH = "yyyy-MM";
  /**
   * 私有构造函数，禁止用户实例化.
   */
  private Utils() {
    super();
  }

  /**
   * 对中文进行GBK转码.
   *
   * @param strSrc 要转码的内容
   * @return 转码后的内容
   */
  public static String encodeGbk(String strSrc) throws Exception{

    if (strSrc == null) {
      return "";
    }
    try {
      strSrc = new String(strSrc.trim().getBytes(
          "ISO-8859-1"), "GBK");
    }
    catch (IOException IOe) {
      IOe.printStackTrace();
    }

    return strSrc.trim();
  }

  /**
   * 字符串转码
   * @param a_str 字符串值
   * @param a_orig: 如 "ISO-8859-1"
   * @param a_dest: 如 "GB2312"
   * @return 转码后的值
   * @throws Exception
   */
  public static String convertEncode(String a_str, String a_orig,
                                     String a_dest) throws Exception {
    byte[] temp = a_str.getBytes(a_orig);
    return new String(temp, a_dest);
  }

  /**
   * 将字符串以char分割, 如:
   * 字符串 "1,2,3,4,5" 被字符','分割成含字符串"1","2","3","4","5"的String数组
   * @param a_str 被分隔的字符串
   * @param a_ch 分隔符
   * @return
   */
  public static String[] split(String a_str, char a_ch) throws Exception{
    char[] splitter = {
        a_ch};
    return split(a_str, new String(splitter));
  }

  /**
   * 将字符串以String分割, 如:
   * 字符串 "1,2,3,4,5" 被字符串","分割成含字符串"1","2","3","4","5"的String数组
   * @param a_str 被分隔的字符串
   * @param a_ch 分隔字符串
   * @return
   */
  public static String[] split(String a_str, String a_ch) throws Exception{
    Vector ret = new Vector();
    int pos = 0;
    while (a_str.length() > 0) {
      String tmp = null;
      pos = a_str.indexOf(a_ch);
      if (pos != -1) { // still has splitter
        tmp = a_str.substring(0, pos);
        a_str = a_str.substring(pos + a_ch.length());
      }
      else {
        tmp = a_str;
        a_str = "";
      }
      ret.add(tmp);
    }

    // 将Vector中数据导入数组
    int count = ret.size();
    String[] results = new String[count];
    for (int i = 0; i < count; i++) {
      results[i] = (String) ret.elementAt(i);
    }
    return results;
  }

  /**
   * 将字符串拆分为ArrayList格式.
   *
   * @param strRoleIdList 要拆分的内容
   * @param strDelim 分隔符
   * @return 拆分为ArrayList格式后的内容
   */
  public static ArrayList toArrayList(String strSrc, String strDelim) throws Exception{
    ArrayList alList = new ArrayList();
    if (strSrc == null || strSrc.trim().length() == 0) {
      return alList;
    }

    StringTokenizer token = new StringTokenizer(strSrc, strDelim);
    while (token.hasMoreElements()) {
      alList.add(token.nextElement());
    }
    return alList;
  }

  /**
   * 合并两个List，重复元素只保存一份.
   *
   * @param list1 要合并的第一个List
   * @param list2 要合并的第二个List
   */
  public static List combineTwoLists(List list1, List list2) throws Exception{
    for (int i = 0, n = list1.size(); i < n; i++) {
      if (!list2.contains(list1.get(i))) {
        list2.add(list1.get(i));
      }
    }
    return list2;
  }

  /**
   * 取得当前系统时间.
   *
   * @return Timestamp 当前系统时间
   * @param strFormat 取得的系统时间的表示格式，默认为“yyyy-MM-dd HH:mm:ss”
   */
  public static Timestamp getCurrentTime(String strFormat) throws Exception{
    if (strFormat == null || strFormat.trim().equals("")) {
      strFormat = "yyyy-MM-dd HH:mm:ss";
    }
    // 取得当前时间
    java.text.SimpleDateFormat formater =
        new java.text.SimpleDateFormat(strFormat);
    java.util.Date date = new java.util.Date();
    String dateString = formater.format(date);
    return new java.sql.Timestamp(0).valueOf(dateString);
  }

  /**
   * 取得当前系统时间.
   *
   * @return Timestamp 以“yyyy-MM-dd HH:mm:ss”格式表示的当前系统时间
   */
  public static Timestamp getCurrentTime() throws Exception{
    return getCurrentTime(null);
  }

  /**
   * 将字符型数字转为Date类型
   * @param value  要转换的字符
   * @return       Date类型的日期
   */
  public static java.util.Date stringToDate(String value) throws Exception{
	  if (value == null || value.equals("")) {
		  return null;
	  }
	  if (value.length() <= 17) {
		  for (int i = 0; value.length() < 17; i++) {
			  value += "0";
		  }
	  } else {
		  value = value.substring(0, 16);
	  }
	  SimpleDateFormat _formatdate = new SimpleDateFormat(YEAR_TO_MSECOND_C,
			  Locale.getDefault());
	  java.util.Date _date = _formatdate.parse(value);
	  return _date;
  }
  
  /**
   * 将字符型数字转为Date类型
   * @param value  要转换的字符
   * @return       Date类型的日期
   */
  public static java.util.Date stringToDate2(String value) throws Exception{
	  SimpleDateFormat _formatdate = new SimpleDateFormat(YEAR_MOUTH_DAY);
	  java.util.Date _date = _formatdate.parse(value);
	  return _date;
  }

  /**
	 * 将字符型数字转为Date类型
	 * 
	 * @param value
	 *            要转换的字符
	 * @param DateTypeString
	 *            日期格式
	 * @return Date类型的日期
	 */
  public static java.util.Date stringToDate(String value,
                                            String DateTypeString) throws Exception{
	  if (value == null || value.equals("")) {
		  return null;
	  }
	  if (value.length() <= 17) {
		  for (int i = 0; value.length() < 17; i++) {
			  value += "0";
		  }
	  }
	  else {
		  value = value.substring(0, 16);
	  }
	  SimpleDateFormat formatdate = new SimpleDateFormat(DateTypeString,
			  Locale.getDefault());
	  java.util.Date date = formatdate.parse(value);
	  return date;
  }

  /**
   * 将字符串转换成Timestamp类型, 能够识别的格式包括:
   * yyyy-mm-dd hh:mm:ss.fffffffff
   * yyyy-mm-dd hh:mm:ss
   * yyyy-mm-dd hh:mm
   * yyyy-mm-dd
   * @param a_s 字符串的时间值
   * @return
   * @throws Exception
   */
  public static Timestamp getTimestamp(String a_s) throws Exception {

    // s should be in yyyy-mm-dd hh:mm:ss.fffffffff format

    try {
      // assuming yyyy-mm-dd hh:mm:ss.fffffffff
      return Timestamp.valueOf(a_s);
    }
    catch (IllegalArgumentException e) {
    }
    try {
      // assuming yyyy-mm-dd hh:mm:ss
      return Timestamp.valueOf(a_s + ".000000000");
    }
    catch (IllegalArgumentException e) {
    }
    try {
      // assuming yyyy-mm-dd hh:mm
      return Timestamp.valueOf(a_s + ":00.000000000");
    }
    catch (IllegalArgumentException e) {
    }
    try {
      // assuming yyyy-mm-dd
      return Timestamp.valueOf(a_s + " 00:00:00.000000000");
    }
    catch (IllegalArgumentException e) {
    }

    throw new Exception(a_s + " is not in valid Timestamp format.");
  }

  /**
   * 把包含日期值转换为字符串
   * @param date 日期（日期+时间）
   * @param type 输出类型
   * @return     字符串
   */
  public static String DateTimeToString(java.util.Date date, String type) throws Exception{
    String DateString = "";
    if (date == null) {
      DateString = "";
    }
    else {
      SimpleDateFormat formatDate = new SimpleDateFormat(type,
          Locale.getDefault());
      DateString = formatDate.format(date);
    }
    return DateString;
  }

  /**
   * 判断是否一个有效日期（包括闰年）
   * @param year 年
   * @param month 月
   * @param day 日
   * @return
   */
  public static boolean checkValidDate(String year, String month, String day) throws Exception{
    Calendar cal = checkDateValid(year, month, day);
    if (cal == null) {
      return false;
    }
    int newYear = cal.get(Calendar.YEAR);
    if (newYear != Integer.parseInt(year)) {
      return false;
    }
    int newMonth = cal.get(Calendar.MONTH) + 1;
    if (newMonth != Integer.parseInt(month)) {
      return false;
    }
    int newDay = cal.get(Calendar.DATE);
    if (newDay != Integer.parseInt(day)) {
      return false;
    }
    return true;
  }

  private static Calendar checkDateValid(String year, String month,
                                         String day) throws Exception{
    String dateString = "";
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd",
        Locale.getDefault());
    dateString = year + "-" + month + "-" + day;
    Calendar c = Calendar.getInstance();
    c.setTime(formatter.parse(dateString));
    return c;
  }

  /**
   * 计算字符串是否为空, 空是指: null 或 空串 或 全是空格的字符串
   * @param a_value
   * @return
   */
  public static boolean isEmpty(String a_value){
    if (a_value == null || a_value.trim().equals("")) {
      return true;
    }
    else {
      return false;
    }
  }

  /**
   * 获得一个类的名字，不含包名的
   * @param a_class
   * @return
   */
  public static String getAClassName(Class a_class) throws Exception{
    if (a_class.getPackage() == null) {
      return a_class.getName();
    }
    else {
      String packageName = a_class.getPackage().getName();
      String className = a_class.getName();
      return className.substring(packageName.length() + 1);
    }
  }

  /**
   * 储存SESSION
   * @param FieldName SESSOIN名
   * @param Value     SESSION值
   * @param request   HttpServletRequest
   */
  public static void setSession(String FieldName, String Value,
                                HttpServletRequest request) throws Exception{
      HttpSession session = request.getSession();
      session.setAttribute(FieldName, Value);
  }

  /**
   * 储存SESSION
   * @param FieldName SESSOIN名
   * @param Value     SESSION值
   * @param request   HttpServletRequest
   */
  public static void setSession(String FieldName, Object Value,
                                HttpServletRequest request) throws Exception{
      HttpSession session = request.getSession();
      session.setAttribute(FieldName, Value);
  }

  /**
   * 得到SEESION值
   * @param FieldName SESSOIN名
   * @param DefaultValue 默认值
   * @param request HttpServletRequest
   * @return
   */
  public static String getSession(String FieldName, String DefaultValue,
                                  HttpServletRequest request) throws Exception{
      HttpSession session = request.getSession();
      String value = (String) session.getAttribute(FieldName);
      if (value == null) {
        value = DefaultValue;
      }
      return value;
  }

  /**
   * 得到SEESION值
   * @param FieldName SESSOIN名
   * @param DefaultValue 默认值
   * @param request HttpServletRequest
   * @return
   */
  public static Object getSession(String FieldName, Object DefaultValue,
                                  HttpServletRequest request) throws Exception{
      HttpSession session = request.getSession();
      Object value = session.getAttribute(FieldName);
      if (value == null) {
        value = DefaultValue;
      }
      return value;
  }

  public static String trimString(String Value) throws Exception{
    return Value == null ? "" : Value.trim();
  }

  /**
   * 取得oracle数据表的sequence值
   * @param string表名
   * @return int sequence
   * @throws Exception
   */
//  public static int getSequence(String table) throws Exception{
//    Connection conn = null;
//    Statement stmt = null;
//    int seq = 0;
//    try {
//      String strSQL = "select " + table + ".nextval from dual";
//
//      conn = ConnectionBuilder.getConnection(false);
//      stmt = conn.createStatement();
//      ResultSet rs = stmt.executeQuery(strSQL);
//
//      if (rs.next()) {
//        seq = rs.getInt("nextval");
//      }
//      // 关闭结果集
//      rs.close();
//    }
//    catch (Exception ex) {
//      throw ex;
//    }
//    finally {
//      // 关闭数据库连接
//    	try {
//    		conn.close();
//    	} catch (SQLException e) {
//    		e.printStackTrace();
//    	}
//    }
//    return seq;
//  }

  /**
   * 根据传入的SQL取得数据表记录数据
   * @param string SQL查询语句
   * @return int count
   * @throws Exception
   */
//  public static int getCount(String sql) throws Exception{
//    Connection conn = null;
//    Statement stmt = null;
//    String strSql;
//    int count = 0;
//    if (sql == null || sql.trim().equals("")) {
//      return 0;
//    }
//    else {
//      strSql = sql.toLowerCase();
//      if (strSql.indexOf("group") != -1) {
//        strSql = "select count(*) from ( " + sql + " )";
//      }
//    }
//    //生成查询记录数的SQL语句
//    //sql = "select count(*) " + strSql;
//    try {
//      conn = ConnectionBuilder.getConnection(false);
//      stmt = conn.createStatement();
//      ResultSet rs = stmt.executeQuery(strSql);
//      if (rs.next()) { //取得满足条件的记录数
//    	  count = rs.getInt(1);
//      }
//      // 关闭结果集
//      rs.close();
//      stmt.close();
//    }
//    catch (Exception ex) {
//      throw ex;
//    }
//    finally {
//      // 关闭数据库连接
//    	try {
//    		conn.close();
//    	} catch (SQLException e) {
//    		e.printStackTrace();
//    	}
//    }
//    return count;
//  }

  /**
   * 对int写数据库进行处理.
   *
   * @param order 要写入的字段在PreparedStatement中的序号
   * @param strSrc 要写入数据库的值
   * @param stmt PreparedStatement对象
   * @throws SQLException 数据库操作出错时抛出
   */
  public static void intToDB2(int index, String strValue,
                              PreparedStatement stmt) throws Exception {
    if (strValue == null || strValue.trim().equals("")) {
      stmt.setNull(index, java.sql.Types.INTEGER);
    }
    else {
      int iValue = 0;
      iValue = Integer.valueOf(strValue).intValue();
      stmt.setInt(index, iValue);
    }
  }

  /**
   * 对float写数据库进行处理.
   *
   * @param order 要写入的字段在PreparedStatement中的序号
   * @param strSrc 要写入数据库的值
   * @param stmt PreparedStatement对象
   * @throws SQLException 数据库操作出错时抛出
   */
  public static void floatToDB2(int index, String strValue,
                                PreparedStatement stmt) throws Exception {
    if (strValue == null || strValue.trim().equals("")) {
      stmt.setNull(index, java.sql.Types.FLOAT);
    }
    else {
      float fValue = 0.0f;
      fValue = Float.valueOf(strValue).floatValue();
      stmt.setFloat(index, fValue);
    }
  }

  /**
   * 对TimeStamp写数据库进行处理.
   *
   * @param order 要写入的字段在PreparedStatement中的序号
   * @param strSrc 要写入数据库的值
   * @param strFormat TimeStamp的格式字符串
   * @param stmt PreparedStatement对象
   * @throws SQLException 数据库操作出错时抛出
   */
  public static void timestampToDB2(int index, String strValue,
                                    String strFormat, PreparedStatement stmt) throws
      Exception {
    if (strValue == null || strValue.trim().equals("")) {
      stmt.setNull(index, java.sql.Types.TIMESTAMP);
    }
    else {
        stmt.setTimestamp(index, Utils.toTimestamp(strValue, strFormat));
    }
  }

  /**
   * 处理SQL条件中的单引号问题，单引号转换为双引号
   * @param value 需要转化的字符串
   * @return 转化后的字符串
   */
  public static String HandleQuotes(String value) throws Exception{
    return value.replace('\'', '\"');
  }

  /**
   * 将String类型转换为int类型
   * @param value  要转换的字符串
   * @return       int类型，当字符串为空时返回0
   */
  public static int stringToInt(String value) throws Exception{
    int _result = 0;
    if (value != null && !value.equals("")) {
      _result = Integer.parseInt(value);
    }
    return _result;
  }

  /**
   * 将String类型转换为int类型
   * @param value  要转换的字符串
   * @return       int类型，当字符串为空时返回0
   */
  public static double stringToDouble(String value) throws Exception{
    double _result = 0;
    if (value != null && !value.equals("")) {
      _result = Double.parseDouble(value);
    }
    return _result;
  }

  /**
   * 将指定格式的日期/时间字符串转换成Timestamp格式.
   *
   * @param strDateTime 日期/时间字符串
   * @param strFormat 日期/时间格式
   * @return Timestamp 类型的日期/时间
   * version 1.0
   * version 1.0.1 由杨建军修改 修改原因:添加strDateTime为NULL时候的判断
   */
  public static Timestamp toTimestamp(String strDateTime, String strFormat) throws
      Exception {
    if (strDateTime == null) { //add by yangjj <version 1.0.1>
      return null; //add by yangjj <version 1.0.1>
    }
    SimpleDateFormat formater = new SimpleDateFormat(strFormat);
    String dateString = formater.format(formater.parse(strDateTime));
    return new Timestamp(0).valueOf(dateString + " 00:00:00");
  }

  /**
   * 将指定格式的日期/时间字符串转换成Date格式
   * @param strDate    String类型，日期字符
   * @param strFormat  String类型，格式
   * @return           Date类型
   */
  public static java.sql.Date toDate(String strDate, String strFormat) throws Exception{
      if (strDate == null || strDate.equals("")) {
        return null;
      }
      else {
        SimpleDateFormat _formatdate = new SimpleDateFormat(strFormat,
            Locale.getDefault());
        java.sql.Date _date = new java.sql.Date( (_formatdate.parse(
            strDate)).getTime());
        return _date;
      }
  }

  /**
   * 将指定格式的日期/时间字符串转换成Date格式
   * @param strDate    String类型，日期字符
   * @param strFormat  String类型，格式
   * @return           Date类型
   * @throws java.lang.Exception
   */
  public static java.util.Date toUtilDate(String strDate, String strFormat) throws
      Exception {
      if (strDate == null || strDate.equals("")) {
        return null;
      }
      else {
        SimpleDateFormat _formatdate = new SimpleDateFormat(strFormat,
            Locale.getDefault());
        java.util.Date _date = new java.util.Date( (_formatdate.parse(
            strDate)).getTime());
        return _date;
      }
  }

  /**
   * 将指定格式的‘YYYY-MM-DD’字符串转换成Date格式
   * @param strDate    String类型，日期字符
   * @param strFormat  String类型，格式
   * @return           Date类型
   * @throws java.lang.Exception
   */
  public static java.util.Date toSimpleDate(String strDate) throws
      Exception {
      if (strDate == null || strDate.equals("")) {
        return null;
      }
      else { //pattern中年日为大写，月为小写:yyyy-MM-dd
        SimpleDateFormat _formatdate = new SimpleDateFormat("yyyy-MM-dd",
            Locale.getDefault());
        java.util.Date _date = new java.util.Date( (_formatdate.parse(
            strDate)).getTime());
        return _date;
      }
  }

  /**
   * 检查 string b是否包含string a
   * @param    String类型
   * @param    String类型
   * @return   boolean
   */

  public static boolean isInclude(String str, String model) throws Exception{
    boolean revalue = false;
    int len = str.length();

    String[] FSTRING2 = {
        model};
    for (int i = 0; i < len; i++) {
      for (int j = 0; j < FSTRING2.length; j++) {
        if (str.indexOf(FSTRING2[j]) < 0) {
          revalue = false;
        }
        else {
          revalue = true;
          break;
        }
      }
    }
    return revalue;
  }

  /**
   * 处理Memo类型字段在HTML的显示，空格转换为&nbsp;，回车转换为<br>
   * @param value Memo类型字段的值
   * @return
   */
  public static String HandleMemo(String value) throws Exception{
    if (value == null) {
      return null;
    }
    // value = value.replaceAll(" ", "&nbsp;");
    // value = value.replaceAll("\r\n", "<br>");//it's the method for jdk1.4
    value = replace(value, " ", "&nbsp;");
    value = replace(value, "\r\n", "<br>");

    return value;
  }

  /**
   * 字符串替换
   * @param    String类型
   * @param    String类型
   * @param    String类型
   * @return   String类型
   */
  public static String replace(String src, String oldstr, String newstr) throws Exception{
    if (src == null) {
      return null;
    }

    StringBuffer dest = new StringBuffer("");

    int len = oldstr.length();
    int srclen = src.length();
    int pos = 0;
    int oldpos = 0;

    while ( (pos = src.indexOf(oldstr, oldpos)) >= 0) {
      dest.append(src.substring(oldpos, pos));
      dest.append(newstr);
      oldpos = pos + len;
    }

    if (oldpos < srclen) {
      dest.append(src.substring(oldpos, srclen));
    }
    return dest.toString();
  }

  /**
   * 在PreparedStatement中，向INT字段写入NULL值
   * @param stmt
   * @param index
   * @param value
   * @throws SQLException
   */
  public static void SetIntValue(PreparedStatement stmt, int index,
                                 String value) throws Exception {
    intToDB2(index, value, stmt);
  }

  /**
   * 在PreparedStatement中，向Double字段写入值.
   * @param stmt
   * @param index
   * @param value
   * @throws SQLException
   */

  public static void SetDoubleValue(PreparedStatement stmt, int index,
                                    String strValue) throws Exception {
    if (strValue != null && strValue.trim().equals("")) {
      strValue = null;
    }

    if (strValue == null) {
      stmt.setNull(index, java.sql.Types.DOUBLE);
    }
    else {

      double iValue = 0;
      iValue = Double.valueOf(strValue).doubleValue();
      stmt.setDouble(index, iValue);
    }

  }

  /**
   * 把Timestamp的变量转换为SQL语句条件中的值
   * @param Timestamp
   * @return
   */
  public static String getDBDateFieldValue(Timestamp timestamp) throws Exception{
    if (timestamp == null) {
      return null;
    }
    java.util.Date date = new java.util.Date();
    date.setTime(timestamp.getTime());
    return DateTimeToString(date, YEAR_TO_MSECOND_C);
  }

  /**
   * 把java.util.Date的变量转换为SQL语句条件中的值
   * @param Timestamp
   * @return
   */
  public static String getDBDateFieldValue(java.util.Date date) throws Exception{
    if (date == null) {
      return null;
    }
    return DateTimeToString(date, YEAR_TO_MSECOND_C);
  }

  /**
   * 替换匹配的第一个字符串
   * @param Value 源字符串
   * @param matchString 匹配的字符串
   * @param replaceString 要替换的字符串
   * @return
   */
  public static String replaceFirst(String Value, String matchString,
                                    String replaceString) throws Exception{
    int pos = Value.indexOf(matchString);
    int len = matchString.length();
    if (pos < 0) {
      return Value;
    }
    String firstString = Value.substring(0, pos);
    String endString = Value.substring(pos + len);
    return firstString + replaceString + endString;

  }

  /**
   * 转换日期字符串，如“2003-10-1”-》“2003-10-01”
   * @param DateString
   * @return
   */
  public static String HandleDateStringWith0(String DateString) throws Exception{
      SimpleDateFormat _formatdate = new SimpleDateFormat(SIMPLE_DATE,
          Locale.getDefault());
      java.util.Date _date = _formatdate.parse(DateString);
      return DateTimeToString(_date, SIMPLE_DATE);
  }

  /**
   * 重定向URL，避免出现存盘-》后退-》再存盘的情况
   * @param UrlString
   * @param Request
   * @return
   */
//  public static String goToPage(String UrlString, HttpServletRequest Request) throws Exception{
//    Request.getSession().setAttribute(
//        ConstValues.SESSION_FORWARD, UrlString);
//    return "TEMP_FORWARD";
//
//  }

  /**
   * 得到一个字符串的真正长度，如果字符串包含汉字，则一个汉字当作两个字符
   * @param Value  字符串
   * @return       字符串真正长度
   */
  public static int getTrueSizeFromString(String Value) throws Exception{
    if (Value == null) {
      return 0;
    }
    int intLen = Value.getBytes().length;
    return intLen;

  }

  /**
   * 将一对象转换为字符串
   * @param obj  对象
   * @return       字符串
   */
  public static String getString(Object obj) throws Exception{
    if (obj == null) {
      return "";
    }
    return obj.toString().trim();

  }

  /**
   * 在日期字符串中取出年的个位数部分
   * @param date  yyyy-MM-dd格式的日期字符串对象
   * @return       字符串
   */
  public static String getYearLast(String date) throws Exception{
    if (date == null || date.trim().equals("")) {
      return "";
    }
    String year = "";
    String dates[] = date.split("-");
    if (dates.length == 3) {
      year = dates[0]; //取年部分
      if (year.length() > 1) { //取最后一位
        year = year.substring(year.length() - 1, year.length());
      }
    }
    return year;
  }

  /**
   * 在日期字符串中取出年的部分
   * @param date  yyyy-MM-dd格式的日期字符串对象
   * @return       字符串
   */
  public static String getYear(String date) throws Exception{
    if (date == null || date.trim().equals("")) {
      return "";
    }
    String year = "";
    String dates[] = date.split("-");
    if (dates.length == 3) {
      year = dates[0]; //取年部分

    }
    return year;
  }

  /**
   * 在日期字符串中取出月部分
   * @param date  yyyy-MM-dd格式的日期字符串对象
   * @return       字符串
   */
  public static String getMonth(String date) throws Exception{
    if (date == null || date.trim().equals("")) {
      return "";
    }
    String month = "";
    String dates[] = date.split("-");
    if (dates.length == 3) {
      month = dates[1]; //取月部分
    }
    return month;
  }

  /**
   * 在日期字符串中取出日部分
   * @param date  yyyy-MM-dd格式的日期字符串对象
   * @return       字符串
   */
  public static String getDay(String date) throws Exception{
    if (date == null || date.trim().equals("")) {
      return "";
    }
    String day = "";
    String dates[] = date.split("-");
    if (dates.length == 3) {
      day = dates[2]; //取日部分
    }
    return day;
  }

  /**
   * 取得所有String类型的域
   */
  public static String getFormFields(Class clazz) throws Exception{
    Field[] fiels = clazz.getDeclaredFields();
    StringBuffer formFields = new StringBuffer("");
    for (int i = 0; i < fiels.length; i++) {
      if (!fiels[i].getType().getName().equals("java.lang.String")) {
        System.out.println(fiels[i].getType().getName());
        continue;
      }
      if (i > 0) {
        formFields.append(",");
      }
      formFields.append(fiels[i].getName());
    }
    return formFields.toString();
  }
  
  /**
   * 对id类型的转换
   * @param java.io.Serializable[] delids转换后的集合
   * @param java.io.Serializable[] ids转换前的集合
   * @throws AppException 系统异常，最后由系统显示在浏览器内
   */
  public static void convertId(java.io.Serializable[] delids,
                        java.io.Serializable[] ids) throws Exception {
      //对ids的数据类型进行转化，使得与数据库中的类型一致
      for (int i = 0; i < ids.length; i++) {
          delids[i] = Long.valueOf((String) ids[i]);
      }
  }
  
  /**
   * 产生唯一ID
   * @param prefix
   * @return ID字符串
   * @throws Exception
   */
  public static String buildId(String prefix)throws Exception{
	  String id=getDBDateFieldValue(new java.util.Date());
	  Random random=new Random();
	  long number=random.nextLong();
	  if (number<0){
		  number=-number;
	  }
	  id=prefix+id+number;
	  return id;
  }
  
  /**
   * 产生唯一ID
   * @param prefix 前置
   * @param random 随机函数
   * @return
   * @throws Exception
   */
  public static String buildId(String prefix,Random random)throws Exception{
	  String id=getDBDateFieldValue(new java.util.Date());
	  long number=random.nextLong();
	  if (number<0){
		  number=-number;
	  }
	  id=prefix+id+number;
	  return id;
  }
  
  public static boolean isOverRealLength(String str, int max) {
	  char[] cs = str.toCharArray();
	  int count = 0;
	  int last = cs.length;
	  for (int i = 0; i < last; i++) {
		  if (cs[i] > 255){
			  count += 2;
		  }else{
			  count++;
		  }
	  }
	  if (count > max){
		  //字符串太长
		  return true;
	  }else{
		  // 字符串太短
		  return false;
	  }
  }
  
  public static String getStrByRealLength(String str, int num) {
	  char[] cs = str.toCharArray();
	  int count = 0;
	  int last = cs.length;
	  int index=0;
	  String realString="";
	  for (int i = 0; i < last; i++) {
		  if (cs[i] > 255){
			  count += 2;
		  }else{
			  count++;
		  }
		  if (count>num){
			  break;
		  }
		  index++;
	  }
	  if (count>num){
		  realString=str.substring(0, index);
	  }else{
		  realString=str;
	  }
	  return realString;
  }
  
  public static int getStringRealLength(String str){
	  char[] cs = str.toCharArray();
	  int count = 0;
	  int last = cs.length;
	  for (int i = 0; i < last; i++) {
		  if (cs[i] > 255){
			  count += 2;
		  }else{
			  count++;
		  }
	  }
	  return count;
  }
  
	public static String unescape(String src) {
		StringBuffer tmp = new StringBuffer();
		tmp.ensureCapacity(src.length());
		int lastPos = 0, pos = 0;
		char ch;
		while (lastPos < src.length()) {
			pos = src.indexOf("%", lastPos);
			if (pos == lastPos) {
				if (src.charAt(pos + 1) == 'u') {
					ch = (char) Integer.parseInt(src
							.substring(pos + 2, pos + 6), 16);
					tmp.append(ch);
					lastPos = pos + 6;
				} else {
					ch = (char) Integer.parseInt(src
							.substring(pos + 1, pos + 3), 16);
					tmp.append(ch);
					lastPos = pos + 3;
				}
			} else {
				if (pos == -1) {
					tmp.append(src.substring(lastPos));
					lastPos = src.length();
				} else {
					tmp.append(src.substring(lastPos, pos));
					lastPos = pos;
				}
			}
		}
		return tmp.toString();
	}
	
	public static String toUtf8String(String s) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c >= 0 && c <= 255) {
				sb.append(c);
			} else {
				byte[] b;
				try {
					b = Character.toString(c).getBytes("utf-8");
				} catch (Exception ex) {
					System.out.println(ex);
					b = new byte[0];
				}
				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0)
						k += 256;
					sb.append("%" + Integer.toHexString(k).toUpperCase());
				}
			}
		}
		return sb.toString();
	}

//  public static String getStrByRealLength(String str, int num) {
//	  String myStr = "";
//	  int strl1 = 0;
//	  int forNum = 0;
//	  int alli = 0;
//	  int strLen = str.length();
//	  for (int i = 0; i < strLen; i++) {
//		  if (str.substring(i, i + 1).getBytes().length > 1){
//			  forNum = forNum + 2;
//		  }else {
//			  strl1 = strl1 + 1;
//			  forNum = forNum + 1;
//		  }
//		  if (forNum > num){
//			  break;
//		  }
//		  alli = alli + 1;
//	  }
//	  if (strLen > alli){
//		  myStr = str.substring(0, alli);
//	  }else{
//		  myStr = str.substring(0, strLen);
//	  }
//	  return myStr;
//  }
  
  public static void main(String[] args){
//	  Object obj="中a华b人c民共和国";
//	  System.out.println(obj.getClass().getSimpleName());
	  String str="中 国";
	  int num=4;
	  String newstr=Utils.getStrByRealLength(str, num);
	  System.out.println("newstr="+newstr);
//	  Utils.isOverRealLength(str, num);
//	  String filename="E:\\cjobjfile\\";
//	  File file=new File(filename);
//	  System.out.println(file.exists());
  }
}